package sandbox

// import (
// 	"strings"

// 	"chainmaker/pb/protogo"
// 	"chainmaker/sdk"

// 	"go.uber.org/zap"
// )

// const (
// 	//_dockerGoMethodInitContract    = "InitContract"
// 	//_dockerGoMethodUpgradeContract = "UpgradeContract"

// 	_initContract    = "init_contract"
// 	_upgradeContract = "upgrade"
// 	_invokeContract  = "invoke_contract" //Compatible with version < 2.3.0
// )

// type TxHandler struct {
// 	sandboxLogger  *zap.SugaredLogger
// 	contractLogger *zap.SugaredLogger
// 	contract       sdk.Contract
// 	contractName   string
// 	processName    string
// 	txId           string
// 	originalTxId   string
// 	crossCtx       *protogo.CrossContext
// 	chainId        string

// 	sendSyscallMsg        func(msg *protogo.DockerVMMessage, responseNotify func(msg *protogo.DockerVMMessage))
// 	txFinishMsgNotifyFunc func(signal *protogo.DockerVMMessage)
// 	pendingQueue          chan *protogo.DockerVMMessage
// }

// func newHandler(contract sdk.Contract, processName, contractName string, logger *zap.SugaredLogger) *TxHandler {
// 	return &TxHandler{
// 		sandboxLogger:  logger,
// 		contractLogger: newDockerLogger(contractLoggerModule, config.LogLevel),
// 		contract:       contract,
// 		contractName:   contractName,
// 		processName:    processName,
// 		pendingQueue:   make(chan *protogo.DockerVMMessage, 200),
// 	}
// }

// // PutMsg put txRequest to pendingQueue
// func (h *TxHandler) PutMsg(msg *protogo.DockerVMMessage) {
// 	h.sandboxLogger.Debugf("put txRequest to pending queue, txTd [%s], txType [%s]", msg.TxId, msg.Type)
// 	h.pendingQueue <- msg
// }

// // RegisterTxFinishMsgNotifyFunc register func to send tx finish msg to engine
// func (h *TxHandler) RegisterTxFinishMsgNotifyFunc(txFinishMsgNotifyFunc func(msg *protogo.DockerVMMessage)) {
// 	h.txFinishMsgNotifyFunc = txFinishMsgNotifyFunc
// }

// // PutMsgWithNotify put tx request to handler and register finish signal callback func
// func (h *TxHandler) PutMsgWithNotify(msg *protogo.DockerVMMessage,
// 	txFinishMsgNotifyFunc func(msg *protogo.DockerVMMessage)) {
// 	h.RegisterTxFinishMsgNotifyFunc(txFinishMsgNotifyFunc)
// 	h.PutMsg(msg)
// }

// // RegisterSyscallMsgSendFunc register runtime client syscall func with call back func
// func (h *TxHandler) RegisterSyscallMsgSendFunc(f func(msg *protogo.DockerVMMessage,
// 	syscallResponseNotifyFunc func(msg *protogo.DockerVMMessage))) {
// 	h.sendSyscallMsg = f
// }

// func (h *TxHandler) sendResponse(resp *protogo.DockerVMMessage) {
// 	h.sendSyscallMsg(resp, nil)
// }

// func (h *TxHandler) Start() error {
// 	h.sandboxLogger.Info("start listen pending queue")
// 	return h.listenPendingQueue()
// }

// func (h *TxHandler) listenPendingQueue() error {
// 	errCh := make(chan error)
// 	for {
// 		select {
// 		case msg := <-h.pendingQueue:
// 			h.sandboxLogger.Debugf("get msg from pending queue, txId: [%s], msgType: [%s]", msg.TxId, msg.Type)
// 			if err := h.handleTxRequest(msg); err != nil {
// 				errCh <- err
// 			}
// 		case err := <-errCh:
// 			return err
// 		}
// 	}
// }

// func getOriginalTxId(txId string) string {
// 	return strings.Split(txId, "#")[0]
// }

// func (h *TxHandler) handleTxRequest(msg *protogo.DockerVMMessage) error {
// 	h.chainId = msg.ChainId
// 	h.txId = msg.TxId
// 	h.originalTxId = getOriginalTxId(h.txId)
// 	h.crossCtx = msg.CrossContext
// 	h.crossCtx.ProcessName = h.processName

// 	args := msg.GetRequest().GetParameters()

// 	s := sdk.NewSDK(
// 		h.crossCtx,
// 		h.sendSyscallMsg,
// 		h.txId,
// 		h.originalTxId,
// 		h.chainId,
// 		h.contractName,
// 		h.contractLogger,
// 		h.sandboxLogger,
// 		args,
// 	)

// 	sdk.Instance = s

// 	method := msg.Request.Method

// 	// compatible with version < 2.3.0 (method in parameters)
// 	if method == _invokeContract {
// 		if methodByte, ok := msg.Request.Parameters["method"]; ok {
// 			// found method, replace 'invoke_contract' method to real method
// 			method = string(methodByte)
// 		}
// 	}

// 	var response protogo.Response
// 	switch method {
// 	case _initContract:
// 		response = h.contract.InitContract()
// 	case _upgradeContract:
// 		response = h.contract.UpgradeContract()
// 	default:
// 		response = h.contract.InvokeContract(method)
// 	}

// 	// construct complete message
// 	writeMap := s.GetWriteMap()
// 	readMap := s.GetReadMap()
// 	events := s.GetEvents()

// 	txResponse := &protogo.TxResponse{
// 		TxId:    h.txId,
// 		ChainId: h.chainId,
// 	}

// 	signal := &protogo.DockerVMMessage{
// 		ChainId:        h.chainId,
// 		TxId:           msg.TxId,
// 		CrossContext:   h.crossCtx,
// 		Type:           protogo.DockerVMType_COMPLETED,
// 		SysCallMessage: nil,
// 		Request:        nil,
// 		Response:       nil,
// 	}

// 	if response.Status == 0 {
// 		txResponse.Code = protogo.DockerVMCode_OK
// 		txResponse.Result = response.Payload
// 		txResponse.Message = "Success"
// 		txResponse.WriteMap = writeMap
// 		txResponse.ReadMap = readMap

// 		var responseEvents []*protogo.DockerContractEvent
// 		for _, event := range events {
// 			responseEvents = append(responseEvents, &protogo.DockerContractEvent{
// 				Topic:        event.Topic,
// 				ContractName: event.ContractName,
// 				Data:         event.Data,
// 			})
// 		}
// 		txResponse.Events = responseEvents

// 	} else {
// 		txResponse.Code = protogo.DockerVMCode_FAIL
// 		txResponse.Result = []byte(response.Message)
// 		txResponse.Message = "Fail"
// 		txResponse.WriteMap = nil
// 		txResponse.ReadMap = nil
// 		txResponse.Events = nil
// 		if method == _initContract || method == _upgradeContract {
// 			signal.Type = protogo.DockerVMType_ERROR
// 		}
// 	}

// 	respMsg := &protogo.DockerVMMessage{
// 		ChainId:        h.chainId,
// 		TxId:           h.txId,
// 		Type:           protogo.DockerVMType_TX_RESPONSE,
// 		Response:       txResponse,
// 		Request:        nil,
// 		SysCallMessage: nil,
// 	}

// 	h.sendResponse(respMsg)

// 	// 发送finish信号
// 	h.txFinishMsgNotifyFunc(signal)
// 	return nil
// }
